/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package co.dzgroup.votacion.implementacion;

import co.dzgroup.votacion.conexion.BaseDatos;
import co.dzgroup.votacion.modelo.Administrador;
import co.dzgroup.votacion.modelo.Barrio;
import co.dzgroup.votacion.modelo.Candidato;
import co.dzgroup.votacion.modelo.Comuna;
import co.dzgroup.votacion.modelo.Departamento;
import co.dzgroup.votacion.modelo.Eleccion;
import co.dzgroup.votacion.modelo.Municipio;
import co.dzgroup.votacion.modelo.PartidoPolitico;
import co.dzgroup.votacion.modelo.Persona;
import co.dzgroup.votacion.modelo.TipoEleccion;
import co.dzgroup.votacion.modelo.Votante;
import co.dzgroup.votacion.modelo.Voto;
import co.dzgroup.votacion.util.Formato;
import java.net.UnknownHostException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import org.apache.log4j.Logger;

/**
 * Clase para ejecutar todas las implementaciones de los método de base de datos,
 * para los métodos de parametrización de información.
 * @author Lucho
 */
public class ParametrizacionImpl {

    private Logger log=Logger.getLogger(ParametrizacionImpl.class);
    private StringBuilder sql;

    /**
     * Constructor por defecto de la clase
     */
    public ParametrizacionImpl() {
    }

    /**
     * Método para crear el partido politico
     * @param partidoPolitico
     * @param bd
     * @return
     */
    public boolean guardarPartidoPolitico(BaseDatos bd,PartidoPolitico partidoPolitico){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("INSERT INTO partido_politico( ");
        sql.append("partido_politico_id, nombre, descripcion, estado) ");
        sql.append("VALUES (?, ?, ?, ?); ");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                preparedStatement.setInt(1,bd.consecutivo("partido_politico", "partido_politico_id"));
                preparedStatement.setString(2,partidoPolitico.getNombre());
                preparedStatement.setString(3,partidoPolitico.getDescripcion());
                preparedStatement.setBoolean(4,partidoPolitico.getEstado());
                int numeroInsercion=preparedStatement.executeUpdate();
                //Si el número de inserción es mayor a cero indica que la operación se
                //realizó correctamente
                if(numeroInsercion>0){
                    resultado=true;
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return resultado;
    }

    /**
     * Método para guardar la elección
     * @param bd
     * @param eleccion
     * @return TRUE si guardo el registro correctamente, de lo contrario devuelve FALSE.
     */
    public Eleccion guardarEleccion(BaseDatos bd, Eleccion eleccion){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("INSERT INTO eleccion( ");
        sql.append("eleccion_id, nombre, fecha_eleccion, hora_inicio, hora_fin, descripcion,estado) ");
        sql.append("VALUES (?, ?, ?, ?, ?, ?, ?); ");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                int eleccionId=bd.consecutivo("eleccion","eleccion_id");
                eleccion.setEleccionId(eleccionId);
                preparedStatement=bd.crearSentencia(sql.toString());
                preparedStatement.setInt(1,eleccionId);
                preparedStatement.setString(2,eleccion.getNombre());
                preparedStatement.setDate(3,Formato.convertirFechaDateASQL(eleccion.getFechaEleccion()));
                preparedStatement.setTime(4,eleccion.getHoraInicio());
                preparedStatement.setTime(5,eleccion.getHoraFin());
                preparedStatement.setString(6,eleccion.getDescripcion());
                preparedStatement.setBoolean(7,Boolean.TRUE);
                int numeroInsercion=preparedStatement.executeUpdate();
                //Si el número de inserción es mayor a cero indica que la operación se
                //realizó correctamente
                if(numeroInsercion>0){
                    //Guardamos los tipos de elección seleccionado en la elección
                    resultado=guardarEleccionTipoEleccion(bd, eleccion);
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarEleccion:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return eleccion;
    }

    /**
     * Método para guardar los tipos de elección asociados a la elección
     * @param bd
     * @param eleccion
     * @return TRUE si se guardaron los datos correctamente, de lo contrario devuelve FALSE.
     */
    public boolean guardarEleccionTipoEleccion(BaseDatos bd, Eleccion eleccion){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("INSERT INTO eleccion_tipo_eleccion( ");
        sql.append("eleccion_id, tipo_eleccion_id) ");
        sql.append("VALUES (?, ?); ");
        
        try{
            preparedStatement=bd.crearSentencia(sql.toString());
            for(TipoEleccion tipoEleccion:eleccion.getTiposEleccion()){
                preparedStatement.setInt(1,eleccion.getEleccionId());
                preparedStatement.setInt(2,tipoEleccion.getTipoEleccionId());
                preparedStatement.addBatch();
            }
            //Si el número de inserción es mayor a cero indica que la operación se
            //realizó correctamente
            int numeroInserciones []=preparedStatement.executeBatch();
            if(numeroInserciones.length>0){
                //Guardamos los tipos de elección seleccionado en la elección
                resultado=true;
            }
            //Cerramos la conexión a la base de datos
            preparedStatement.clearBatch();
            bd.cerrar();
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarEleccionTipoEleccion:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return resultado;
    }

    /**
     * Método para consultar los tipos de elección
     * @param bd
     * @return List<TipoEleccion>
     */
    public List<TipoEleccion> consultarTiposEleccion(BaseDatos bd){
        List<TipoEleccion> listado=new ArrayList<TipoEleccion>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder("SELECT * FROM tipo_eleccion");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    TipoEleccion tipoEleccion=new TipoEleccion(resultSet.getInt("tipo_eleccion_id"),
                            resultSet.getString("nombre").trim());
                    listado.add(tipoEleccion);
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.consultarTiposEleccion:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }

    /**
     * Método para consultar los departamentos
     * @param bd Objetode Base de Datos
     * @return List<Departamento>
     */
    public List<Departamento> consultarDepartamentos(BaseDatos bd){
        List<Departamento> listado=new ArrayList<Departamento>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder("SELECT * FROM departamento ORDER BY nombre");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Departamento departamento=new Departamento(resultSet.getInt("departamento_id"),
                            resultSet.getString("nombre").trim());
                    listado.add(departamento);
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.consultarDepartamentos:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
	
    /**
     * @descripcion Método que permite consultar los tipos de partidos políticos
     * que se encuentran alojados en la base de datos
     * @author Brian Cardona 
     * @param bd la base de datos de donde se va a realizar la consulta
     * @return List<PartidoPolitico> una lista con todos los partidos políticos
     * @exception SQLException problema con la conexión en la base de datos
     * @since 1.0
     */
    public List<PartidoPolitico> consultarPartidosPoliticos(BaseDatos bd){
        List<PartidoPolitico> listado = new ArrayList<PartidoPolitico>();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql = new StringBuilder("SELECT * FROM partido_politico ORDER BY nombre");
        try{
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement = bd.crearSentencia(sql.toString());
                resultSet = preparedStatement.executeQuery();
                while(resultSet.next()){
                    PartidoPolitico partidoPolitico = new PartidoPolitico(
                            resultSet.getString("nombre").trim(),
                            Formato.cambiarSiEsNull(resultSet.getString("descripcion"),"").trim(),
                            resultSet.getBoolean("estado"));
                    partidoPolitico.setPartidoPoliticoId(resultSet.getInt("partido_politico_id"));
                    listado.add(partidoPolitico);
                }
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException ex){
            log.error("Error en el método ParametrizacionImpl.consultarPartidosPoliticos:" + 
                    ex.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
	
    /**
     * @descripcion Método que permite guardar un Candidato en la base de datos
     * @author Brian Cardona
     * @param bd la base de datos de donde se va a realizar la consulta
     * @param candidato el candidato que se va a guardar
     * @return si guardo correctamente o no - True o False
     * @exception SQLException problema con la conexión en la base de datos
     * @since 1.0
     */
    public boolean guardarCandidato(BaseDatos bd, Candidato candidato) {
        PreparedStatement preparedStatement = null;
        try{
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                candidato.setPersonaId(bd.consecutivo("persona","persona_id"));
                //Guardamos primero la persona
                if(guardarPersona(candidato, bd)){
                    sql = new StringBuilder();
                    sql.append("INSERT INTO candidato( ");
                    sql.append("candidato_id, persona_id, partido_politico_id, tipo_eleccion_id, foto, propuestas) ");
                    sql.append("VALUES (?, ?, ?, ?, ?, ?); ");
                    preparedStatement = bd.crearSentencia(sql.toString());
                    preparedStatement.setInt(1,bd.consecutivo("candidato","candidato_id"));
                    preparedStatement.setInt(2,candidato.getPersonaId());
                    preparedStatement.setInt(3,candidato.getPartidoPolitico().getPartidoPoliticoId());
                    preparedStatement.setInt(4,candidato.getTipoEleccion().getTipoEleccionId());
                    preparedStatement.setString(5,candidato.getFoto());
                    preparedStatement.setString(6,candidato.getPropuestas());
                    int numeroInserciones  = preparedStatement.executeUpdate();
                    if(numeroInserciones > 0){
                        return true;
                    }
                }
                bd.cerrar();
            }
        }catch(SQLException ex){
            log.error("Error en el método ParametrizacionImpl.guardarCandidato:" +
                    ex.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return false;
    }

    public Candidato seleccionarCandidato(BaseDatos bd){
        PreparedStatement preparedStatement=null;
        String consulta= new String();
        sql=new StringBuilder();
        sql.append("select * from Candidato ");
        consulta="select * from Candidato where candidato_id=1";
        Candidato candidato= new Candidato();
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);

                ResultSet rs=preparedStatement.executeQuery();


                while (rs.next()){
                   /** candidato.setFoto(rs.getBytes("foto"));
                    candidato.setFotoprueba(rs.getString("fotoprueba"));*/
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return candidato;
    }


    /**
     * Metodo que consulta los candidatos asociados al tipo de eleccion
     * @param bd
     * @param tipoEleccion_id
     * @return
     */
    public List<Candidato> seleccionarCandidatosPorTipoEleccion(BaseDatos bd,Integer tipoEleccion_id){
        List<Candidato> listadoCandidato=new ArrayList<Candidato>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder("SELECT * FROM candidato c,Persona p where p.persona_id=c.persona_id and tipo_eleccion_id=? ");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                preparedStatement.setInt(1,tipoEleccion_id);
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){

                    Candidato candidato= new Candidato(resultSet.getString("documento"),
                            resultSet.getString("nombre"), resultSet.getString("foto"));
                    candidato.setCandidatoId(Integer.parseInt(resultSet.getString("candidato_id")));
                    listadoCandidato.add(candidato);
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.consultarTiposEleccion:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listadoCandidato;
    }


    public Persona seleccionarPersona(BaseDatos bd,Integer personaId){

        PreparedStatement preparedStatement=null;
        String consulta= new String();
        Persona persona=new Persona();
        consulta="select * from Candidato where persona_id=?";
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,personaId);
                ResultSet rs=preparedStatement.executeQuery();


                while (rs.next()){
                    persona=new Persona(rs.getString("nombre"),rs.getString("documento"),
                            rs.getDate("fecha_nacimiento"), rs.getString("direccion"),
                            rs.getString("telefono"), rs.getString("email"));
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return persona;
    }


    /**
     * Método para crear el partido politico
     * @param partidoPolitico
     * @param bd
     * @return
     */
    public boolean guardarVoto(BaseDatos bd,Voto voto){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        if(voto.getCandidato()!=null && voto.getCandidato().getCandidatoId()!=null){
            sql.append("INSERT INTO voto( ");
            //Revisar tipo eleccion relacion en base de datos
            //sql.append("voto_id, tipo_elecccion_id, candidato_id, votante_id, barrio_id,voto_blanco,voto_nulo)");
            sql.append("voto_id, candidato_id, votante_id, barrio_id,voto_blanco,voto_nulo,eleccion_id,ip_equipo,tipo_eleccion_id,fecha,hora)");
            sql.append("VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,current_date,current_time); ");
            try{
                //Se realiza la conexión a pool
                if(bd.conectar(BaseDatos.DATA_SOURCE)){
                    preparedStatement=bd.crearSentencia(sql.toString());
                    preparedStatement.setInt(1,bd.consecutivo("voto", "voto_id"));
                    //preparedStatement.setInt(2,voto.getTipoEleccion().getTipoEleccionId());
                    preparedStatement.setInt(2,voto.getCandidato().getCandidatoId());
                    preparedStatement.setInt(3,voto.getVotante().getVotanteId());
                    preparedStatement.setInt(4,voto.getBarrio().getBarrioId());
                    preparedStatement.setBoolean(5,voto.isVoto_blanco());
                    preparedStatement.setBoolean(6,voto.isVoto_nulo());
                    preparedStatement.setInt(7,voto.getEleccion().getEleccionId());
                    try {
                        preparedStatement.setString(8, Formato.getIpEquipo());
                    } catch (UnknownHostException ex) {
                         bd.cerrar();
                         log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:");
                    }
                    preparedStatement.setInt(9, voto.getTipoEleccion().getTipoEleccionId());
                    //preparedStatement.setDate(6,fecha???);
                    int numeroInsercion=preparedStatement.executeUpdate();
                    //Si el número de inserción es mayor a cero indica que la operación se
                    //realizó correctamente
                    if(numeroInsercion>0){
                        resultado=true;
                    }
                    //Cerramos la conexión a la base de datos
                    bd.cerrar();
                }else{
                    log.error("No se pudo realizar una conexión a la base de datos");
                }
            }catch(SQLException se){
                log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
            }finally{
                BaseDatos.cerrarStatement(preparedStatement);
            }
        }else{
            sql.append("INSERT INTO voto( ");
            //Revisar tipo eleccion relacion en base de datos
            //sql.append("voto_id, tipo_elecccion_id, candidato_id, votante_id, barrio_id,voto_blanco,voto_nulo)");
            sql.append("voto_id,votante_id, barrio_id,voto_blanco,voto_nulo,eleccion_id,ip_equipo,tipo_eleccion_id,fecha,hora)");
            sql.append("VALUES (?,?, ?, ?, ?, ?, ?, ?,current_date,current_time); ");
            try{
                //Se realiza la conexión a pool
                if(bd.conectar(BaseDatos.DATA_SOURCE)){
                    preparedStatement=bd.crearSentencia(sql.toString());
                    preparedStatement.setInt(1,bd.consecutivo("voto", "voto_id"));
                    preparedStatement.setInt(2,voto.getVotante().getVotanteId());
                    preparedStatement.setInt(3,voto.getBarrio().getBarrioId());
                    preparedStatement.setBoolean(4,voto.isVoto_blanco());
                    preparedStatement.setBoolean(5,voto.isVoto_nulo());
                    preparedStatement.setInt(6,voto.getEleccion().getEleccionId());
                    try {
                        preparedStatement.setString(7, Formato.getIpEquipo());
                    } catch (UnknownHostException ex) {
                         bd.cerrar();
                         log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:");
                    }
                    preparedStatement.setInt(8, voto.getTipoEleccion().getTipoEleccionId());
                    //preparedStatement.setDate(6,fecha???);
                    int numeroInsercion=preparedStatement.executeUpdate();
                    //Si el número de inserción es mayor a cero indica que la operación se
                    //realizó correctamente
                    if(numeroInsercion>0){
                        resultado=true;
                    }
                    //Cerramos la conexión a la base de datos
                    bd.cerrar();
                }else{
                    log.error("No se pudo realizar una conexión a la base de datos");
                }
            }catch(SQLException se){
                log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
            }finally{
                BaseDatos.cerrarStatement(preparedStatement);
            }
        }

        return resultado;
    }


    /**
     * MÃ©todo para consultar la lista de departamentos
     * @param bd
     * @return List<Departamento>
     */
    public List<Departamento> consultarDepartamento(BaseDatos bd){
        List<Departamento> listado=new ArrayList<Departamento>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder("SELECT * FROM departamento ORDER BY nombre");
        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Departamento departamento=new Departamento(resultSet.getInt("departamento_id"),
                            resultSet.getString("nombre").trim());
                    listado.add(departamento);
                }
                //Cerramos la conexiÃ³n a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.consultarDepartamento:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
    /**
     * MÃ©todo para consultar la lista de municipios
     * @param bd
     * @return List<Municipio>
     */
    public List<Municipio> consultarMunicipio(BaseDatos bd){
        List<Municipio> listado=new ArrayList<Municipio>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder();
         sql.append("SELECT * FROM public.departamento, public.municipio ");
         sql.append("WHERE departamento.departamento_id = municipio.departamento_id ");
         sql.append("ORDER BY departamento.departamento_id,municipio.nombre");
        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Departamento departamento=new Departamento(resultSet.getInt(1),
                            resultSet.getString(2).trim());
                    Municipio municipio=new Municipio(resultSet.getInt(3),
                            resultSet.getString(4).trim(),departamento);
                    listado.add(municipio);
                }
                //Cerramos la conexiÃ³n a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.consultarMunicipio:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
     /**
     * MÃ©todo para listar comunas
     * @param municipio_id
     * @return List<Comuna>
     * @throws SQLException
     */
    public List<Comuna> consultarComuna(BaseDatos bd) {
        List<Comuna> listado=new ArrayList<Comuna>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder();
        sql.append("SELECT * FROM departamento d, municipio m, comuna c ");
        sql.append("WHERE d.departamento_id = m.departamento_id AND m.municipio_id = c.municipio_id ");
        sql.append("ORDER BY m.municipio_id,c.nombre");
        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Departamento departamento=new Departamento(resultSet.getInt(1),
                            resultSet.getString(2).trim());
                    Municipio municipio=new Municipio(resultSet.getInt(3),
                            resultSet.getString(4).trim(),departamento);
                    Comuna comuna=new Comuna(resultSet.getInt(6),
                            resultSet.getString(7).trim(),municipio);
                    listado.add(comuna);
                }
                //Cerramos la conexiÃ³n a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.consultarComuna:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
    /**
     * MÃ©todo para listar barrios
     * @param comuna_id
     * @return List<Barrio>
     * @throws SQLException
     */
    public List<Barrio> consultarBarrio(BaseDatos bd) {
        List<Barrio> listado=new ArrayList<Barrio>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder();
        sql.append("SELECT * FROM departamento d, municipio m, comuna c,");
        sql.append(" barrio b WHERE d.departamento_id = m.departamento_id ");
        sql.append("AND m.municipio_id = c.municipio_id AND b.comuna_id = c.comuna_id ");
        sql.append("ORDER BY c.comuna_id,b.nombre");
        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Departamento departamento=new Departamento(resultSet.getInt(1),
                            resultSet.getString(2).trim());
                    Municipio municipio=new Municipio(resultSet.getInt(3),
                            resultSet.getString(4).trim(),departamento);
                    Comuna comuna=new Comuna(resultSet.getInt(6),
                            resultSet.getString(7).trim(),municipio);
                    Barrio barrio=new Barrio(resultSet.getInt(9),
                            resultSet.getString(10).trim(),comuna);
                    listado.add(barrio);
                }
                //Cerramos la conexiÃ³n a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.consultarBarrio:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }
    /**
     * MÃ©todo para crear el persona
     * @param persona
     * @param bd
     * @return TRUE si se guardÃ³ la informaciÃ³n correctamente, de lo contrario devuelve FALSE
     * @throws SQLException
     */
    public boolean guardarPersona(Persona persona,BaseDatos bd){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("INSERT INTO persona( ");
        sql.append("persona_id, nombre, documento, fecha_nacimiento, direccion, telefono, email, codigo_logueo) ");
        sql.append("VALUES (?, ?, ?, ?, ?, ?, ?, ?); ");
        try{
            preparedStatement=bd.crearSentencia(sql.toString());
            preparedStatement.setInt(1,persona.getPersonaId());
            preparedStatement.setString(2,persona.getNombre());
            preparedStatement.setString(3,persona.getDocumento());
            preparedStatement.setDate(4, Formato.convertirFechaDateASQL(persona.getFechaNacimiento()));
            preparedStatement.setString(5,persona.getDireccion());
            preparedStatement.setString(6,persona.getTelefono());
            preparedStatement.setString(7,persona.getEmail());
            preparedStatement.setString(8,persona.getCodigoLogueo());
            int numeroInsercion=preparedStatement.executeUpdate();
            //Si el nÃºmero de inserciÃ³n es mayor a cero indica que la operaciÃ³n se
            //realizÃ³ correctamente
            if(numeroInsercion>0){
                resultado=true;
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.guardarPersona:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

       return resultado;
    }
    /**
     * MÃ©todo para guardar la informaciÃ³n del votante
     * @param votante
     * @return TRUE si se guardÃ³ la informaciÃ³n correctamente, de lo contrario devuelve FALSE
     * @throws SQLException
     */
    public boolean guardarVotante(Votante votante,BaseDatos bd) {
       boolean resultado=false;
        PreparedStatement preparedStatement=null;        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                votante.setPersonaId(bd.consecutivo("persona","persona_id"));
                //Si la persona se guarda correctamente se guardar la información del votante
                if(guardarPersona(votante, bd)){
                    sql=new StringBuilder();
                    sql.append("INSERT INTO votante( ");
                    sql.append("votante_id, persona_id, barrio_id) ");
                    sql.append("VALUES (?, ?, ?); ");
                    preparedStatement=bd.crearSentencia(sql.toString());
                    preparedStatement.setInt(1,bd.consecutivo("votante", "votante_id"));
                    preparedStatement.setInt(2,votante.getPersonaId());
                    preparedStatement.setInt(3,votante.getBarrio().getBarrioId());
                    int numeroInsercion=preparedStatement.executeUpdate();
                    //Si el nÃºmero de inserciÃ³n es mayor a cero indica que la operaciÃ³n se
                    //realizÃ³ correctamente
                    if(numeroInsercion>0){
                        resultado=true;
                    }
                    //Cerramos la conexiÃ³n a la base de datos
                    bd.cerrar();
                }
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.guardarVotante:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

       return resultado;
    }

    /**
     * Método para consulta las elecciones para el dia actual
     * @param partidoPolitico
     * @param bd
     * @return
     */
    public List<Eleccion> consultarEleccionActual(BaseDatos bd){
        PreparedStatement preparedStatement=null;
        List<Eleccion> listaEleccion= new ArrayList<Eleccion>();
        String consulta="";
        consulta="select * from eleccion where fecha_eleccion=current_date and estado=true";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);

                ResultSet rs=preparedStatement.executeQuery();

                listaEleccion.clear();
                while (rs.next()){
                    Eleccion eleccion= new Eleccion(rs.getInt("eleccion_id"),
                            rs.getString("nombre") , rs.getBoolean("estado"),
                            rs.getDate("fecha_eleccion"), rs.getTime("hora_inicio"),
                            rs.getTime("hora_fin"),rs.getString("descripcion"));
                    eleccion.setCandidatos(consultarCandidatosEleccion(bd,eleccion.getEleccionId()));
                    eleccion.setTiposEleccion(consultarTipoEleccionPoreleccion(bd,eleccion.getEleccionId()));
                    listaEleccion.add(eleccion);
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listaEleccion;
    }

    /**
     * Metodo que consulta los candidatos de una eleccion especifica
     * @param bd
     * @param eleccionId
     * @return
     */
    private List<Candidato> consultarCandidatosEleccion(BaseDatos bd, Integer eleccionId){
        List<Candidato> listaCandidatos= new ArrayList<Candidato>();
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from eleccion_candidato e INNER JOIN candidato c ON(e.candidato_id=c.candidato_id) INNER JOIN persona p ON(c.persona_id=p.persona_id)  where e.eleccion_id=?";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccionId);

                ResultSet rs=preparedStatement.executeQuery();

                listaCandidatos.clear();
                while (rs.next()){

                    Candidato candidato= new Candidato(rs.getString("documento"),
                            rs.getString("nombre"), rs.getString("foto"));
                    TipoEleccion tipoEleccion= new TipoEleccion();
                    tipoEleccion.setTipoEleccionId(rs.getInt("tipo_eleccion_id"));
                    candidato.setTipoEleccion(tipoEleccion);
                    candidato.setCandidatoId(Integer.parseInt(rs.getString("candidato_id")));
                    listaCandidatos.add(candidato);
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return listaCandidatos;
    }

    /**
     * Metodo que consulta los candidatos de una eleccion especifica
     * @param bd
     * @param eleccionId
     * @return
     */
    private List<TipoEleccion> consultarTipoEleccionPoreleccion(BaseDatos bd, Integer eleccionId){
        List<TipoEleccion> listaTipoEleccion= new ArrayList<TipoEleccion>();
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from eleccion_tipo_eleccion e INNER JOIN tipo_eleccion t ON(e.tipo_eleccion_id=t.tipo_eleccion_id) where e.eleccion_id=?";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccionId);

                ResultSet rs=preparedStatement.executeQuery();

                listaTipoEleccion.clear();
                while (rs.next()){

                    TipoEleccion tipoEleccion=new TipoEleccion(rs.getInt("tipo_eleccion_id"),
                            rs.getString("nombre").trim());
                    listaTipoEleccion.add(tipoEleccion);
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return listaTipoEleccion;
    }

    /**
     * Método para consultar el votante por el documento de identidad
     * @param bd
     * @param documento
     * @return Null si el votante por ese documento no se encuentra, de lo
     * contrario devuelve el objeto con Votante con todos sus atributos.
     */
    public Votante consultarVotantePorDocumento(BaseDatos bd,String documento){
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        Votante votante=null;
        @SuppressWarnings("LocalVariableHidesMemberVariable")
        StringBuilder sql=new StringBuilder();
        sql.append("SELECT votante_id,p.persona_id,p.nombre as votante, ");
        sql.append("documento,fecha_nacimiento,direccion,telefono,email, ");
        sql.append("b.barrio_id,b.nombre as barrio,p.codigo_logueo ");
        sql.append("FROM votante v ");
        sql.append("INNER JOIN persona p ON(v.persona_id=p.persona_id) ");
        sql.append("INNER JOIN barrio b ON(b.barrio_id=v.barrio_id) ");
        sql.append("WHERE p.documento=? ");
        try{
            //Se realiza la conexiÃ³n a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                preparedStatement.setString(1, documento);
                resultSet=preparedStatement.executeQuery();
                while(resultSet.next()){
                    Barrio barrio=new Barrio();
                    barrio.setBarrioId(resultSet.getInt("barrio_id"));
                    barrio.setNombre(resultSet.getString("barrio"));
                    votante=new Votante(resultSet.getString("votante"), resultSet.getString("documento"),
                            resultSet.getDate("fecha_nacimiento"), resultSet.getString("direccion"),
                            resultSet.getString("telefono"), resultSet.getString("email"),
                            resultSet.getInt("votante_id"), barrio);
                    votante.setPersonaId(resultSet.getInt("persona_id"));
                    votante.setCodigoLogueo(resultSet.getString("codigo_logueo"));
                }
                //Cerramos la conexiÃ³n a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexiÃ³n a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el mÃ©todo ParametrizacionImpl.consultarVotantePorDocumento:"+se.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return votante;
    }

    /**
     * Método para actualizar el código de logueo de la persona
     * @param bd
     * @param personaId
     * @param clave
     * @return TRUE si se actualizó correctamente el código de logueo de la persona,
     * de lo contrario devuelve FALSE.
     */
    public boolean actualizarCodigoLogueoPersona(BaseDatos bd, Integer personaId,String clave){
        boolean resultado=true;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("UPDATE persona SET codigo_logueo=? ");
        sql.append("WHERE persona_id = ? ");
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement =bd.crearSentencia(sql.toString());
                preparedStatement.setString(1,clave);
                preparedStatement.setInt(2, personaId);
                int numeroActualizacion=preparedStatement.executeUpdate();
                if(numeroActualizacion>0){
                    resultado=true;
                }
                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.actualizarCodigoLogueoPersona:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return resultado;
    }

     /**
     * Metodo que consulta el votante asociado al psw y contraseña
     * @param bd
     * @param usuario
     * @param psw
     * @autor carlos valencia
     * @return
     */
    public Votante consultarVotante(BaseDatos bd, String usuario,String psw){
        Votante votante=null;
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from votante v INNER JOIN persona p ON(v.persona_id=p.persona_id) where p.documento=? and p.codigo_logueo=?";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setString(1,usuario);
                preparedStatement.setString(2,psw);
                ResultSet rs=preparedStatement.executeQuery();

                while (rs.next()){
                    votante= new Votante();
                    votante.setVotanteId(rs.getInt("votante_id"));
                    votante.setNombre(rs.getString("nombre"));
                    votante.setPersonaId(rs.getInt("persona_id"));
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();

            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return votante;
    }

    /**
     * Metodo que consulta el admininistrador asociado al psw y el usuario
     * @param bd
     * @param usuario
     * @param psw
     * @autor carlos Valencia
     * @return
     */
    public Administrador consultarAdministrador(BaseDatos bd, String usuario,String psw){
        Administrador admin=null;
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from administrador a INNER JOIN persona p ON(a.persona_id=p.persona_id) where p.documento=? and a.codigo_logueo=?";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setString(1,usuario);
                preparedStatement.setString(2,psw);
                ResultSet rs=preparedStatement.executeQuery();

                while (rs.next()){
                    admin= new Administrador();
                    admin.setAdministradorId(rs.getInt("administrador_id"));
                    admin.setNombre(rs.getString("nombre"));
                    admin.setPersonaId(rs.getInt("persona_id"));
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();

            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return admin;
    }

    /**
     * Método para consultar los candidatos por tipos de elección
     * @param bd
     * @param tiposEleccion
     * @return List<Candidato>
     */
    public List<Candidato> consultarCandidatosEleccion(BaseDatos bd, String tiposEleccion){
        List<Candidato> listado=new ArrayList<Candidato>();
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        sql=new StringBuilder();
        sql.append("SELECT c.candidato_id,p.nombre as candidato, t.nombre as tipo_eleccion_nombre ");
        sql.append("FROM persona p ");
        sql.append("INNER JOIN candidato c ON(p.persona_id=c.persona_id) ");
        sql.append("INNER JOIN tipo_eleccion t ON(t.tipo_eleccion_id=c.tipo_eleccion_id) ");
        sql.append("WHERE t.tipo_eleccion_id IN(").append(tiposEleccion).append(") order by t.nombre,p.nombre");
        try{
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement = bd.crearSentencia(sql.toString());
                resultSet = preparedStatement.executeQuery();
                while(resultSet.next()){
                    Candidato candidato = new Candidato();
                    candidato.setNombre(resultSet.getString("candidato"));
                    TipoEleccion tipoEleccion=new TipoEleccion();
                    tipoEleccion.setNombre(resultSet.getString("tipo_eleccion_nombre"));
                    candidato.setTipoEleccion(tipoEleccion);
                    candidato.setCandidatoId(resultSet.getInt("candidato_id"));
                    listado.add(candidato);
                }
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException ex){
            log.error("Error en el método ParametrizacionImpl.consultarCandidatosEleccion:" +
                    ex.getMessage());
        }finally{
            BaseDatos.cerrarResultSet(resultSet);
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listado;
    }

    /**
     * Método para guardar los candidatos asociados a la elección
     * @param bd
     * @param eleccion
     * @return TRUE si se guardaron los datos correctamente, de lo contrario devuelve FALSE.
     */
    public boolean guardarEleccionCandidato(BaseDatos bd, Eleccion eleccion){
        boolean resultado=false;
        PreparedStatement preparedStatement=null;
        sql=new StringBuilder();
        sql.append("INSERT INTO eleccion_candidato( ");
        sql.append("eleccion_id, candidato_id) ");
        sql.append("VALUES (?, ?); ");
        try{
            if(bd.conectar(BaseDatos.DATA_SOURCE)){
                preparedStatement=bd.crearSentencia(sql.toString());
                for(Candidato candidato:eleccion.getCandidatos()){
                    preparedStatement.setInt(1,eleccion.getEleccionId());
                    preparedStatement.setInt(2,candidato.getCandidatoId());
                    preparedStatement.addBatch();
                }
                //Si el número de inserción es mayor a cero indica que la operación se
                //realizó correctamente
                int numeroInserciones []=preparedStatement.executeBatch();
                if(numeroInserciones!=null && numeroInserciones.length>0){
                    //Guardamos los candidatos seleccionado en la elección
                    resultado=true;
                }
                //Cerramos la conexión a la base de datos
                preparedStatement.clearBatch();
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarEleccionCandidato:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return resultado;
    }

    /**
     * Metodo que consulta los votantes por un rango de fecha especifico
     * @param bd
     * @param rango
     * @return
     * @autor Andres ruiz
     */
    public List<Votante> consultarVotantesRangoFechas(BaseDatos bd, Integer rango){
        Administrador admin=null;
        PreparedStatement preparedStatement=null;
        String consulta="";
        List<Votante> listaVotantes=new ArrayList<Votante>();
        consulta="select votante_id,nombre,documento,((current_date-p.fecha_nacimiento)/365) as edad from votante v INNER JOIN persona p ON(v.persona_id=p.persona_id)";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                ResultSet rs=preparedStatement.executeQuery();

                while (rs.next()){
                    Votante votante= new Votante();
                    votante.setVotanteId(rs.getInt("votante_id"));
                    votante.setNombre(rs.getString("nombre"));
                    votante.setDocumento(rs.getString("documento"));
                    votante.setEdad(rs.getInt("edad"));
                    int edad=rs.getInt("edad");
                    if(rango!=null){

                        if(rango==1 && edad>=18 && edad<25){
                            listaVotantes.add(votante);
                        }else if(rango==2 && edad>=25 && edad<30){
                            listaVotantes.add(votante);
                        }else if(rango==3 && edad>=30 && edad<40){
                            listaVotantes.add(votante);
                        }else if(rango==2 && edad>=40){
                            listaVotantes.add(votante);
                        }
                    }
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();

            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return listaVotantes;
    }

    /**
     * Metodo que consulta las elecciones realizadas
     * @param bd
     * @return
     */
    public List<Eleccion> consultarElecciones(BaseDatos bd){
        PreparedStatement preparedStatement=null;
        List<Eleccion> listaEleccion= new ArrayList<Eleccion>();
        String consulta="";
        consulta="select * from eleccion";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);

                ResultSet rs=preparedStatement.executeQuery();

                listaEleccion.clear();
                while (rs.next()){
                    Eleccion eleccion= new Eleccion(rs.getInt("eleccion_id"),
                            rs.getString("nombre") , rs.getBoolean("estado"),
                            rs.getDate("fecha_eleccion"), rs.getTime("hora_inicio"),
                            rs.getTime("hora_fin"),rs.getString("descripcion"));
                    eleccion.setCandidatos(consultarCandidatosEleccion(bd,eleccion.getEleccionId()));
                    eleccion.setTiposEleccion(consultarTipoEleccionPoreleccion(bd,eleccion.getEleccionId()));
                    listaEleccion.add(eleccion);
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return listaEleccion;
    }

    /**
     * Metodo que retorna la cantidad de votos sobre una eleccion para un candidato
     * @param bd
     * @param candidato_id
     * @param eleccion_id
     * @return
     */
    public Integer consultarVotosEleccionCandidato(BaseDatos bd,Integer candidato_id,Integer eleccion_id){
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select count(*) as valor from voto v where v.eleccion_id=? and v.candidato_id=?";
        Integer voto=0;
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccion_id);
                preparedStatement.setInt(2,candidato_id);
                ResultSet rs=preparedStatement.executeQuery();
                while (rs.next()){
                    voto=rs.getInt("valor");
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return voto;
    }

    /**
     * Metodo que retorna si el votante ya registro un voto anteriormente
     * @param bd
     * @param candidato_id
     * @param eleccion_id
     * @return
     */
    public boolean consultarVotoVotanteEleccion(BaseDatos bd,Integer votante_id,Integer eleccion_id){
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from voto v inner join votante vo on (v.votante_id=vo.votante_id) inner join persona p on (vo.persona_id=p.persona_id) where v.eleccion_id=? and p.persona_id=?";
        boolean votoRegistrado=false;
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccion_id);
                preparedStatement.setInt(2,votante_id);
                ResultSet rs=preparedStatement.executeQuery();
                while (rs.next()){
                    votoRegistrado=true;
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return votoRegistrado;
    }

    /**
     * Metodo que retorna la cantidad de votos en blanco de una eleccion y un tipo de eleccion
     * @param bd
     * @param candidato_id
     * @param eleccion_id
     * @return
     */
    public Integer consultarVotosBlancoEleccionTipoEleccion(BaseDatos bd,Integer tipo_eleccion_id,Integer eleccion_id){
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select count(*) as valor from voto v where v.eleccion_id=? and v.tipo_eleccion_id=? and v.voto_blanco=true";
        Integer voto=0;
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccion_id);
                preparedStatement.setInt(2,tipo_eleccion_id);
                ResultSet rs=preparedStatement.executeQuery();
                while (rs.next()){
                    voto=rs.getInt("valor");
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return voto;
    }

    /**
     * Metodo que retorna la cantidad de votos en blanco de una eleccion y un tipo de eleccion
     * @param bd
     * @param candidato_id
     * @param eleccion_id
     * @return
     */
    public Integer consultarVotosNulosEleccionTipoEleccion(BaseDatos bd,Integer tipo_eleccion_id,Integer eleccion_id){
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select count(*) as valor from voto v where v.eleccion_id=? and v.tipo_eleccion_id=? and v.voto_nulo=true";
        Integer voto=0;
        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,eleccion_id);
                preparedStatement.setInt(2,tipo_eleccion_id);
                ResultSet rs=preparedStatement.executeQuery();
                while (rs.next()){
                    voto=rs.getInt("valor");
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();
            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }
        return voto;
    }

    /**
     * Metodo que consulta el votante asociado al psw y contraseña
     * @param bd
     * @param usuario
     * @param psw
     * @autor carlos valencia
     * @return
     */
    public Votante consultarVotantePorPersonaId(BaseDatos bd, Integer personaId){
        Votante votante=null;
        PreparedStatement preparedStatement=null;
        String consulta="";
        consulta="select * from votante v INNER JOIN persona p ON(v.persona_id=p.persona_id) where p.persona_id=?";

        try{
            //Se realiza la conexión a pool
            if(bd.conectar(BaseDatos.DATA_SOURCE)){

                preparedStatement =bd.crearSentencia(consulta);
                preparedStatement.setInt(1,personaId);
                ResultSet rs=preparedStatement.executeQuery();

                while (rs.next()){
                    votante= new Votante();
                    votante.setVotanteId(rs.getInt("votante_id"));
                    votante.setNombre(rs.getString("nombre"));
                    votante.setPersonaId(rs.getInt("persona_id"));
                }

                //Cerramos la conexión a la base de datos
                bd.cerrar();

            }else{
                log.error("No se pudo realizar una conexión a la base de datos");
            }
        }catch(SQLException se){
            log.error("Error en el método ParametrizacionImpl.guardarPartidoPolitico:"+se.getMessage());
        }finally{
            BaseDatos.cerrarStatement(preparedStatement);
        }

        return votante;
    }

     /**
     * MÃ©todo para generar codigo de logueo
     * @param longitud codigo del votante
     * @return codigo de logue
     */
    String getCadenaAlfanumAleatoria (int longitud){
        String cadenaAleatoria = "";
        long milis = new java.util.GregorianCalendar().getTimeInMillis();
        Random r = new Random(milis);
        int i = 0;
        while ( i < longitud){
            char c = (char)r.nextInt(255);
            if ( (c >= '0' && c <='9') || (c >='A' && c <='Z') ){
                cadenaAleatoria += c;
                i ++;
            }
        }
        return cadenaAleatoria;
    }



}
